pip install kaggle

Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.6.17)
Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)
Requirement already satisfied: certifi>=2023.7.22 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2024.7.4)
Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)
Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.32.3)
Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.5)
Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.4)
Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.0.7)
Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)
Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)
Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)
Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)
Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.7)

# Import pandas and os modules
import pandas as pd
import os
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from sklearn.preprocessing import LabelEncoder
from imblearn.over_sampling import SMOTE
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.metrics import classification_report, accuracy_score, roc_auc_score, confusion_matrix, mean_squared_error, r2_score, silhouette_score, davies_bouldin_score
from sklearn.decomposition import PCA
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from sklearn.linear_model import LinearRegression
from sklearn.cluster import KMeans, DBSCAN
from sklearn.mixture import GaussianMixture

from google.colab import drive
drive.mount('/content/drive/')

Mounted at /content/drive/

! mkdir drive/MyDrive/BDA-Project/ -p

!if [[ ! -f drive/MyDrive/BDA-Project/ai4i2020.csv ]]; then
!kaggle datasets download -d stephanmatzka/predictive-maintenance-dataset-ai4i-2020 -p drive/MyDrive/BDA-Project/ --unzip

/bin/bash: -c: line 2: syntax error: unexpected end of file
Dataset URL: https://www.kaggle.com/datasets/stephanmatzka/predictive-maintenance-dataset-ai4i-2020
License(s): CC-BY-NC-SA-4.0
Downloading predictive-maintenance-dataset-ai4i-2020.zip to drive/MyDrive/BDA-Project
100% 136k/136k [00:00<00:00, 416kB/s]
100% 136k/136k [00:00<00:00, 415kB/s]

# Verify if the file exists in directory

file_path = "drive/MyDrive/BDA-Project/ai4i2020.csv"

if os.path.isfile(file_path):
    print("The file is already downloaded and ready to use.")
else:
    print("The file is not found. Downloading now...")
    # Here you would put the code to download the file using the Kaggle API
    # For example:
    os.system(f'kaggle datasets download -d stephanmatzka/predictive-maintenance-dataset-ai4i-2020 -p {os.path.dirname(file_path)} --unzip')

The file is already downloaded and ready to use.

# Load data
data = pd.read_csv("drive/MyDrive/BDA-Project/ai4i2020.csv")

# Check the shape of the DataFrame
print("DataFrame Shape:")
print(data.shape)

DataFrame Shape:
(10000, 14)

# Get summary statistics for the DataFrame
print("\nSummary Statistics:")
data.describe()

Summary Statistics:

# Check for missing values in the DataFrame
print("\nMissing Values:")
data.isnull().sum()

Missing Values:

# Check for duplicate rows in the DataFrame
print("\nDuplicate Rows:")
data.duplicated().sum()

Duplicate Rows:

0

# Check for unique values in each column
print("\nUnique Values per Column:")
data.nunique()

Unique Values per Column:

#Correlation
sns.pairplot(data)
plt.show()

# Count of Product Types:

# Create the count plot
plt.figure(figsize=(10, 6))
count_plot = sns.countplot(x='Type', data=data)

# Add title and labels for the axes
plt.title('Count of Product Types')
plt.xlabel('Product Type')
plt.ylabel('Count')

# Add labels with commas to each bar
for p in count_plot.patches:
    count = p.get_height()
    plt.text(p.get_x() + p.get_width() / 2., count + 0.1,  # position the text at the top of the bar
             f'{int(count):,}',  # format the label with commas
             ha="center", va="bottom", fontsize=10)  # ha for horizontal alignment, va for vertical

plt.show()

# Distribution of Process Temperature:

plt.figure(figsize=(10, 6))
sns.histplot(data['Process temperature [K]'], kde=True, bins=30)
plt.title('Distribution of Process Temperature')
plt.xlabel('Process Temperature [K]')
plt.ylabel('Frequency')
plt.show()

#Scatter Plot of Rotational Speed vs. Torque:

plt.figure(figsize=(8, 6))
plt.scatter(data['Rotational speed [rpm]'], data['Torque [Nm]'], alpha=0.5)
plt.title('Rotational Speed vs. Torque')
plt.xlabel('Rotational Speed [rpm]')
plt.ylabel('Torque [Nm]')
plt.show()

# Distribution of Torque:

plt.figure(figsize=(10, 6))
sns.histplot(data['Torque [Nm]'], bins=30)
plt.title('Distribution of Torque')
plt.show()

# Box Plot of Torque by Product Type:
plt.figure(figsize=(10, 6))
sns.boxplot(x='Type', y='Torque [Nm]', data=data)
plt.title('Box Plot of Torque by Product Type')
plt.xlabel('Product Type')
plt.ylabel('Torque [Nm]')
plt.show()

#Box Plot of Tool Wear:

plt.figure(figsize=(8, 6))
sns.boxplot(x='Machine failure', y='Tool wear [min]', data=data)
plt.title('Tool Wear by Machine Failure')
plt.xlabel('Machine Failure (0 = No, 1 = Yes)')
plt.ylabel('Tool Wear [min]')
plt.show()

# Violin Plot of Tool Wear by Product Type:

plt.figure(figsize=(10, 6))
sns.violinplot(x='Type', y='Tool wear [min]', data=data)
plt.title('Violin Plot of Tool Wear by Product Type')
plt.xlabel('Product Type')
plt.ylabel('Tool Wear [min]')
plt.show()

# Histogram of Machine Failures:

# Plot histogram of machine failures
plt.figure(figsize=(8, 6))
ax = data['Machine failure'].value_counts().plot(kind='bar')
plt.title('Distribution of Machine Failures')
plt.xlabel('Machine Failure (0 = No, 1 = Yes)')
plt.ylabel('Frequency')

# Add labels to each bar with commas
for p in ax.patches:
    height = int(p.get_height())
    ax.annotate(f'{height:,}', (p.get_x() + p.get_width() / 2., height),
                ha='center', va='center', xytext=(0, 9), textcoords='offset points')

plt.show()

# Failure rate by machine type
failure_rate = data.groupby('Type')['Machine failure'].mean()
print("Failure rate by machine type:\n", failure_rate)

# Bar plot of failure rates by machine type
plt.figure(figsize=(8, 6))
failure_rate.plot(kind='bar')
plt.title('Failure Rate by Machine Type')
plt.xlabel('Machine Type')
plt.ylabel('Failure Rate')
plt.show()

Failure rate by machine type:
 Type
H    0.020937
L    0.039167
M    0.027694
Name: Machine failure, dtype: float64

# Heatmap of Product Type vs. Machine Failure
contingency_table = pd.crosstab(data['Type'], data['Machine failure'])
sns.heatmap(contingency_table, annot=True, fmt='d', cmap='YlGnBu')
plt.title('Heatmap of Product Type vs. Machine Failure')
plt.xlabel('Machine Failure')
plt.ylabel('Product Type')
plt.show()

# Bar Plot of Torque by Product Type and Machine Failure

plt.figure(figsize=(10, 6))
sns.barplot(x='Type', y='Torque [Nm]', hue='Machine failure', data=data)
plt.title('Bar Plot of Torque by Product Type and Machine Failure')
plt.xlabel('Product Type')
plt.ylabel('Torque [Nm]')
plt.show()

#Time-Based Analysis:

# Assuming there is a timestamp or sequential index for time-based analysis
plt.figure(figsize=(10, 6))
plt.plot(data.index, data['Rotational speed [rpm]'], label='Rotational Speed')
plt.plot(data.index, data['Tool wear [min]'], label='Tool Wear')
plt.title('Rotational Speed and Tool Wear Over Time')
plt.xlabel('Time (Index)')
plt.ylabel('Value')
plt.legend()
plt.show()

#Display the first 5 records of the Dataframe
data.head(5)

data.dtypes
data['Type'] = data['Type'].astype('category')
data['Type'] = data['Type'].cat.codes

data.head(5)

#Class Imbalance Handling:


# Check for class imbalance
class_counts = data['Machine failure'].value_counts()
print("Class distribution:\n", class_counts)

# Separate features (X) and target (y)
X = data.drop('Machine failure', axis=1)
y = data['Machine failure']

# Identify categorical columns (if any)
categorical_columns = X.select_dtypes(include=['object']).columns

# Apply Label Encoding to categorical columns (you can also use OneHotEncoder if needed)
label_encoder = LabelEncoder()
for col in categorical_columns:
    X[col] = label_encoder.fit_transform(X[col])

# Resample using SMOTE
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)

# Check the resampled class distribution
print("Resampled class distribution:\n", pd.Series(y_res).value_counts())

Class distribution:
 Machine failure
0    9661
1     339
Name: count, dtype: int64
Resampled class distribution:
 Machine failure
0    9661
1    9661
Name: count, dtype: int64

class_counts = data['Machine failure'].value_counts()
print("Class distribution:\n", class_counts)

# Scaling columns
scaler = StandardScaler()
data[['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']] = scaler.fit_transform(data[['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']])

# Drop unnecessary columns
data = data.drop(['TWF', 'HDF', 'PWF', 'OSF', 'RNF'], axis=1)

data

#Machine Failure Prediction (Binary Classification):


# Feature selection
X = data[['Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']]
y = data['Machine failure']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Train a Random Forest model
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)

RandomForestClassifier(random_state=42)

RandomForestClassifier(random_state=42)

# Predictions and evaluation
y_pred = clf.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred))

Accuracy: 0.9803333333333333
              precision    recall  f1-score   support

           0       0.98      1.00      0.99      2907
           1       0.85      0.44      0.58        93

    accuracy                           0.98      3000
   macro avg       0.92      0.72      0.79      3000
weighted avg       0.98      0.98      0.98      3000

# New analysis with balanced dataset using SMOTE
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)

# Initialize the Stratified K-Fold cross-validation
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Lists to store metrics for each fold
auc_scores = []
classification_reports = []

# Perform Stratified K-Fold Cross-Validation
for train_index, test_index in skf.split(X_res, y_res):
    # Use iloc to index rows by position in Pandas DataFrame
    X_train, X_test = X_res.iloc[train_index], X_res.iloc[test_index]
    y_train, y_test = y_res.iloc[train_index], y_res.iloc[test_index]

    # Initialize and train a Random Forest Classifier
    rf_model = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')
    rf_model.fit(X_train, y_train)

    # Make predictions on the test set
    y_pred = rf_model.predict(X_test)
    y_pred_proba = rf_model.predict_proba(X_test)[:, 1]  # Probability estimates for ROC AUC

    # Calculate AUC-ROC score for the current fold
    auc_score = roc_auc_score(y_test, y_pred_proba)
    auc_scores.append(auc_score)

    # Generate classification report and store it
    report = classification_report(y_test, y_pred, output_dict=True)
    classification_reports.append(report)

    # Print classification report for the current fold
    print(f"Fold Classification Report:\n{classification_report(y_test, y_pred)}")
    print(f"AUC-ROC Score for Fold: {auc_score:.4f}")

# Evaluate the model
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# Calculate average AUC-ROC score across all folds
average_auc = np.mean(auc_scores)
print(f"\nAverage AUC-ROC Score across all folds: {average_auc:.4f}")

Fold Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.94      0.96      1933
           1       0.94      0.99      0.96      1932

    accuracy                           0.96      3865
   macro avg       0.96      0.96      0.96      3865
weighted avg       0.96      0.96      0.96      3865

AUC-ROC Score for Fold: 0.9942
Fold Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.94      0.96      1932
           1       0.94      0.98      0.96      1933

    accuracy                           0.96      3865
   macro avg       0.96      0.96      0.96      3865
weighted avg       0.96      0.96      0.96      3865

AUC-ROC Score for Fold: 0.9935
Fold Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.94      0.96      1932
           1       0.95      0.98      0.96      1932

    accuracy                           0.96      3864
   macro avg       0.96      0.96      0.96      3864
weighted avg       0.96      0.96      0.96      3864

AUC-ROC Score for Fold: 0.9942
Fold Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.93      0.96      1932
           1       0.94      0.98      0.96      1932

    accuracy                           0.96      3864
   macro avg       0.96      0.96      0.96      3864
weighted avg       0.96      0.96      0.96      3864

AUC-ROC Score for Fold: 0.9931
Fold Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.94      0.96      1932
           1       0.94      0.98      0.96      1932

    accuracy                           0.96      3864
   macro avg       0.96      0.96      0.96      3864
weighted avg       0.96      0.96      0.96      3864

AUC-ROC Score for Fold: 0.9930
Confusion Matrix:
[[1819  113]
 [  46 1886]]

Average AUC-ROC Score across all folds: 0.9936

from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt

# Calculate FPR, TPR, and thresholds for ROC
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)

# Calculate AUC score
roc_auc = auc(fpr, tpr)

# Plot ROC Curve
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='blue', label=f'ROC Curve (area = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='grey', linestyle='--')  # Diagonal line
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend(loc='lower right')
plt.show()

# Get feature importances from the trained model
importances = rf_model.feature_importances_
indices = np.argsort(importances)[::-1]  # Sort feature importances in descending order
features = X.columns.to_numpy()  # Convert features to a numpy array for indexing

# Plot the feature importances
plt.figure(figsize=(12, 8))
sns.barplot(x=importances[indices], y=features[indices])
plt.title('Feature Importance')
plt.xlabel('Importance')
plt.ylabel('Features')
plt.show()

# Principal Component Analysis (PCA) of Industrial Equipment Data

numeric_features = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]',
                    'Torque [Nm]', 'Tool wear [min]']

scaler = StandardScaler()
data_scaled = scaler.fit_transform(data[numeric_features])

pca = PCA(n_components=2)
principal_components = pca.fit_transform(data_scaled)

pca_df = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])

pca_df['Machine failure'] = data['Machine failure']

plt.figure(figsize=(8,6))
plt.scatter(pca_df['PC1'], pca_df['PC2'], c=pca_df['Machine failure'], cmap='viridis')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('PCA of Industrial Equipment Data')
plt.colorbar(label='Machine Failure')
plt.show()

print('Explained variance ratio:', pca.explained_variance_ratio_)

Explained variance ratio: [0.3821481  0.36817048]

# Neural Network Model for Machine Failure Prediction
features = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]',
            'Torque [Nm]', 'Tool wear [min]']
target = 'Machine failure'

X = data[features]
y = data[target]

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)

model = Sequential()

model.add(Dense(64, input_dim=X_train.shape[1], activation='relu'))

model.add(Dense(64, activation='relu'))

model.add(Dense(32, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])

history = model.fit(X_train, y_train, epochs=30, batch_size=32, validation_data=(X_test, y_test))

test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f'Test Accuracy: {test_accuracy * 100:.2f}%')

Epoch 1/30

/usr/local/lib/python3.10/dist-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

219/219 ━━━━━━━━━━━━━━━━━━━━ 3s 5ms/step - accuracy: 0.8337 - loss: 0.3573 - val_accuracy: 0.9690 - val_loss: 0.1181
Epoch 2/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9657 - loss: 0.1101 - val_accuracy: 0.9733 - val_loss: 0.0977
Epoch 3/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9707 - loss: 0.0886 - val_accuracy: 0.9710 - val_loss: 0.0909
Epoch 4/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 6ms/step - accuracy: 0.9672 - loss: 0.0963 - val_accuracy: 0.9757 - val_loss: 0.0762
Epoch 5/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9746 - loss: 0.0722 - val_accuracy: 0.9770 - val_loss: 0.0701
Epoch 6/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9737 - loss: 0.0720 - val_accuracy: 0.9773 - val_loss: 0.0658
Epoch 7/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9765 - loss: 0.0608 - val_accuracy: 0.9803 - val_loss: 0.0602
Epoch 8/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9773 - loss: 0.0647 - val_accuracy: 0.9783 - val_loss: 0.0650
Epoch 9/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9769 - loss: 0.0645 - val_accuracy: 0.9790 - val_loss: 0.0654
Epoch 10/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9818 - loss: 0.0553 - val_accuracy: 0.9797 - val_loss: 0.0593
Epoch 11/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9788 - loss: 0.0528 - val_accuracy: 0.9803 - val_loss: 0.0579
Epoch 12/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9802 - loss: 0.0544 - val_accuracy: 0.9810 - val_loss: 0.0601
Epoch 13/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9784 - loss: 0.0630 - val_accuracy: 0.9843 - val_loss: 0.0516
Epoch 14/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9827 - loss: 0.0515 - val_accuracy: 0.9813 - val_loss: 0.0550
Epoch 15/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.9807 - loss: 0.0610 - val_accuracy: 0.9833 - val_loss: 0.0512
Epoch 16/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9831 - loss: 0.0476 - val_accuracy: 0.9780 - val_loss: 0.0571
Epoch 17/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9805 - loss: 0.0502 - val_accuracy: 0.9843 - val_loss: 0.0520
Epoch 18/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9847 - loss: 0.0469 - val_accuracy: 0.9827 - val_loss: 0.0523
Epoch 19/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9841 - loss: 0.0488 - val_accuracy: 0.9803 - val_loss: 0.0542
Epoch 20/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 6ms/step - accuracy: 0.9780 - loss: 0.0625 - val_accuracy: 0.9833 - val_loss: 0.0498
Epoch 21/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 5ms/step - accuracy: 0.9847 - loss: 0.0458 - val_accuracy: 0.9833 - val_loss: 0.0525
Epoch 22/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - accuracy: 0.9823 - loss: 0.0467 - val_accuracy: 0.9833 - val_loss: 0.0509
Epoch 23/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.9830 - loss: 0.0467 - val_accuracy: 0.9847 - val_loss: 0.0477
Epoch 24/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.9879 - loss: 0.0417 - val_accuracy: 0.9823 - val_loss: 0.0523
Epoch 25/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 1s 6ms/step - accuracy: 0.9830 - loss: 0.0473 - val_accuracy: 0.9873 - val_loss: 0.0455
Epoch 26/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 3s 8ms/step - accuracy: 0.9862 - loss: 0.0429 - val_accuracy: 0.9867 - val_loss: 0.0445
Epoch 27/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 3s 9ms/step - accuracy: 0.9856 - loss: 0.0392 - val_accuracy: 0.9843 - val_loss: 0.0486
Epoch 28/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 3s 9ms/step - accuracy: 0.9869 - loss: 0.0399 - val_accuracy: 0.9857 - val_loss: 0.0469
Epoch 29/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 8ms/step - accuracy: 0.9847 - loss: 0.0420 - val_accuracy: 0.9840 - val_loss: 0.0494
Epoch 30/30
219/219 ━━━━━━━━━━━━━━━━━━━━ 2s 5ms/step - accuracy: 0.9848 - loss: 0.0422 - val_accuracy: 0.9853 - val_loss: 0.0466
94/94 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - accuracy: 0.9821 - loss: 0.0552
Test Accuracy: 98.53%

# Model Accuracy
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Test Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

# Model Loss

plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Test Loss')
plt.title('Model Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

# Linear Regression: Tool Wear Prediction
features = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]']
target = 'Tool wear [min]'

X = data[features]
y = data[target]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train)

y_pred = lr_model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"Linear Regression MSE: {mse}")
print(f"Linear Regression R^2: {r2}")

importance = lr_model.coef_
plt.barh(features, importance)
plt.xlabel('Feature Importance (Coefficient Value)')
plt.title('Feature Importance in Tool Wear Prediction (Linear Regression)')
plt.show()

Linear Regression MSE: 1.055039911963184
Linear Regression R^2: -0.001198736041068127

rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

y_pred_rf = rf_model.predict(X_test)
mse_rf = mean_squared_error(y_test, y_pred_rf)
r2_rf = r2_score(y_test, y_pred_rf)
print(f"Random Forest MSE: {mse_rf}")
print(f"Random Forest R^2: {r2_rf}")

importance_rf = rf_model.feature_importances_
plt.barh(features, importance_rf)
plt.xlabel('Feature Importance (Random Forest)')
plt.title('Feature Importance in Tool Wear Prediction (Random Forest)')
plt.show()

Random Forest MSE: 0.999091366284536
Random Forest R^2: 0.05189462334906736

#Anomaly Detection
from sklearn.ensemble import IsolationForest

# Feature selection
X = data[['Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']]

# Train Isolation Forest model
iso_forest = IsolationForest(contamination=0.01, random_state=42)
anomalies = iso_forest.fit_predict(X)

# Append anomalies to the dataframe
data['Anomaly'] = anomalies
print("Anomalies detected:\n", data[data['Anomaly'] == -1])

Anomalies detected:
        UDI Product ID  Type  Air temperature [K]  Process temperature [K]  \
50      51     L47230     1            -0.552421                -0.610355   
194    195     M15054     2            -0.902393                -1.014761   
344    345     M15204     2            -1.252366                -1.216963   
380    381     L47560     1            -1.252366                -1.149563   
418    419     L47598     1            -1.302362                -1.082162   
...    ...        ...   ...                  ...                      ...   
9406  9407     M24266     2            -1.152374                -1.284364   
9758  9759     L56938     1            -0.702409                -0.138549   
9849  9850     L57029     1            -0.702409                -0.408153   
9865  9866     M24725     2            -0.552421                -0.138549   
9939  9940     H39353     0            -0.852397                -1.284364   

      Rotational speed [rpm]  Torque [Nm]  Tool wear [min]  Machine failure  \
50                  7.375389    -3.549896         0.550644                1   
194                 6.354612    -2.937965        -0.344865                1   
344                 5.071668    -2.626983        -1.240374                0   
380                 5.718718    -2.727300         0.299273                1   
418                 3.414996    -2.235748        -1.695984                0   
...                      ...          ...              ...              ...   
9406                3.626961    -2.446413         1.226203                0   
9758                4.084358    -2.386223         1.728945                1   
9849                4.313057    -2.456445        -1.004714                0   
9865                5.082824    -2.616951        -0.297733                0   
9939                6.120335    -2.727300        -0.376287                0   

      Anomaly  
50         -1  
194        -1  
344        -1  
380        -1  
418        -1  
...       ...  
9406       -1  
9758       -1  
9849       -1  
9865       -1  
9939       -1  

[100 rows x 10 columns]

#Plotting Anomalies

# Create a scatter plot to visualize anomalies based on two features
plt.figure(figsize=(10, 6))

# Normal points (Anomaly = 1)
normal = data[data['Anomaly'] == 1]
# Anomalies (Anomaly = -1)
anomalies = data[data['Anomaly'] == -1]

# Scatter plot for normal points
plt.scatter(normal['Rotational speed [rpm]'], normal['Torque [Nm]'],
            label='Normal', color='blue', alpha=0.5)

# Scatter plot for anomalies
plt.scatter(anomalies['Rotational speed [rpm]'], anomalies['Torque [Nm]'],
            label='Anomaly', color='red', marker='x')

# Add labels and title
plt.xlabel('Rotational speed [rpm]')
plt.ylabel('Torque [Nm]')
plt.title('Anomalies in Rotational Speed and Torque')
plt.legend()
plt.show()

#Predictive Maintenance Scheduling:

# Define the exact features used for training (ensure this matches the training phase)
features_clf = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]']  # Classifier features
features_reg = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]']  # Regression features
target_clf = 'Machine failure'  # Target for classification (failure/no failure)
target_reg = 'Tool wear [min]'  # Target for regression (tool wear)

# Step 1: Split data into training and test sets
X_clf = data[features_clf]
y_clf = data[target_clf]

X_reg = data[features_reg]
y_reg = data[target_reg]

# Split data for classifier
X_train_clf, X_test_clf, y_train_clf, y_test_clf = train_test_split(X_clf, y_clf, test_size=0.2, random_state=42)

# Split data for regression
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)

# Step 2: Scaling the features (StandardScaler)
scaler_clf = StandardScaler()
X_train_clf_scaled = scaler_clf.fit_transform(X_train_clf)
X_test_clf_scaled = scaler_clf.transform(X_test_clf)

scaler_reg = StandardScaler()
X_train_reg_scaled = scaler_reg.fit_transform(X_train_reg)
X_test_reg_scaled = scaler_reg.transform(X_test_reg)

# Step 3: Train the classification model (Random Forest Classifier)
clf = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')
clf.fit(X_train_clf_scaled, y_train_clf)

# Step 4: Train the regression model (Linear Regression)
model = LinearRegression()
model.fit(X_train_reg_scaled, y_train_reg)

# Step 5: Make predictions
# Predicting 'Predicted Failure' using the classifier
data['Predicted Failure'] = clf.predict(scaler_clf.transform(X_clf))

# Predicting 'Predicted Tool Wear' using the regression model
data['Predicted Tool Wear'] = model.predict(scaler_reg.transform(X_reg))

# Step 6: Evaluate the regression model (MSE and R^2)
y_pred_reg = model.predict(X_test_reg_scaled)
mse_reg = mean_squared_error(y_test_reg, y_pred_reg)
r2_reg = r2_score(y_test_reg, y_pred_reg)

print(f"Linear Regression MSE: {mse_reg}")
print(f"Linear Regression R^2: {r2_reg}")

# Step 7: Plot feature importance for Random Forest (classifier)
importances_clf = clf.feature_importances_
indices_clf = importances_clf.argsort()[::-1]

plt.figure(figsize=(10, 6))
plt.barh([features_clf[i] for i in indices_clf], importances_clf[indices_clf])
plt.xlabel('Feature Importance (Classifier)')
plt.title('Feature Importance in Failure Prediction (Random Forest)')
plt.show()

# Step 8: Plot regression coefficients (Linear Regression)
importance_reg = model.coef_
plt.barh(features_reg, importance_reg)
plt.xlabel('Feature Importance (Regression Coefficients)')
plt.title('Feature Importance in Tool Wear Prediction (Linear Regression)')
plt.show()

# Output the first few rows of the updated dataframe to verify predictions
print(data[['Predicted Failure', 'Predicted Tool Wear']].head())

# Step 9: Schedule maintenance if predicted tool wear exceeds the threshold
# Define the maintenance threshold (adjust this value based on your specific needs)
maintenance_threshold = 300  # Example threshold for tool wear (adjust as needed)

# Schedule maintenance if predicted tool wear exceeds the threshold
data['Maintenance Needed'] = data['Predicted Tool Wear'] > maintenance_threshold

# Print the maintenance schedule
print("Maintenance schedule:\n", data[data['Maintenance Needed']])

Linear Regression MSE: 1.055039911963184
Linear Regression R^2: -0.001198736041068127

   Predicted Failure  Predicted Tool Wear
0                  0            -0.003818
1                  0             0.008030
2                  0            -0.009329
3                  0             0.019359
4                  0             0.020897
Maintenance schedule:
 Empty DataFrame
Columns: [UDI, Product ID, Type, Air temperature [K], Process temperature [K], Rotational speed [rpm], Torque [Nm], Tool wear [min], Machine failure, Anomaly, Predicted Failure, Predicted Tool Wear, Maintenance Needed]
Index: []

# Check the range of the predicted tool wear values
print(f"Min Predicted Tool Wear: {data['Predicted Tool Wear'].min()}")
print(f"Max Predicted Tool Wear: {data['Predicted Tool Wear'].max()}")

# Adjust the threshold based on the range of predicted values
maintenance_threshold = 0.015

# Schedule maintenance if predicted tool wear exceeds the threshold
data['Maintenance Needed'] = data['Predicted Tool Wear'] > maintenance_threshold

# Print the maintenance schedule
print("Maintenance schedule:\n", data[data['Maintenance Needed']])

Min Predicted Tool Wear: -0.10794260902004972
Max Predicted Tool Wear: 0.038949273562945134
Maintenance schedule:
        UDI Product ID  Type  Air temperature [K]  Process temperature [K]  \
3        4     L47183     1            -0.902393                -0.947360   
4        5     L47184     1            -0.902393                -0.879959   
5        6     M14865     2            -0.952389                -0.947360   
16      17     M14876     2            -0.702409                -0.542955   
20      21     H29434     0            -0.552421                -0.475554   
...    ...        ...   ...                  ...                      ...   
9989  9990     M24849     2            -0.602417                -1.014761   
9990  9991     L57170     1            -0.602417                -1.014761   
9992  9993     L57172     1            -0.602417                -1.082162   
9994  9995     L57174     1            -0.602417                -1.149563   
9995  9996     M24855     2            -0.602417                -1.082162   

      Rotational speed [rpm]  Torque [Nm]  Tool wear [min]  Machine failure  \
3                  -0.590021    -0.048845        -1.586009                0   
4                  -0.729472     0.001313        -1.554588                0   
5                  -0.634645     0.191915        -1.523166                0   
16                 -1.270539     0.663403        -1.004714                0   
20                 -0.913546     0.272168        -0.784764                0   
...                      ...          ...              ...              ...   
9989                0.213214    -0.680840        -1.695984                0   
9990               -0.065687    -0.379890        -1.648852                0   
9992               -0.305542    -0.078940        -1.570298                0   
9994                0.531161    -1.212518        -1.507456                0   
9995                0.363820    -1.052012        -1.476034                0   

      Anomaly  Predicted Failure  Predicted Tool Wear  Maintenance Needed  
3           1                  0             0.019359                True  
4           1                  0             0.020897                True  
5           1                  0             0.015025                True  
16          1                  0             0.018481                True  
20          1                  0             0.018529                True  
...       ...                ...                  ...                 ...  
9989        1                  0             0.016679                True  
9990        1                  0             0.017300                True  
9992        1                  0             0.017792                True  
9994        1                  0             0.021441                True  
9995        1                  0             0.021407                True  

[1203 rows x 13 columns]

# Clustering for Anomaly Detection

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, davies_bouldin_score

# Assuming `data_scaled` is the scaled data used for PCA
kmeans = KMeans(n_clusters=3, random_state=42)
cluster_labels = kmeans.fit_predict(data_scaled)

# Silhouette Score
silhouette_avg = silhouette_score(data_scaled, cluster_labels)
print(f'Silhouette Score: {silhouette_avg}')

# Davies-Bouldin Score
db_score = davies_bouldin_score(data_scaled, cluster_labels)
print(f'Davies-Bouldin Score: {db_score}')

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)

Silhouette Score: 0.262210380484853
Davies-Bouldin Score: 1.2436547827907212

# Plotting Silhouette Score

from sklearn.metrics import silhouette_samples, silhouette_score
from sklearn.cluster import KMeans


# Set the number of clusters
n_clusters = 3  # Change this to the actual number of clusters you're using

# Fit KMeans model
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
cluster_labels = kmeans.fit_predict(data_scaled)

# Compute the silhouette scores for each sample
silhouette_values = silhouette_samples(data_scaled, cluster_labels)

# Silhouette Score for the entire model
silhouette_avg = silhouette_score(data_scaled, cluster_labels)

# Plot the Silhouette Plot
fig, ax = plt.subplots(figsize=(8, 6))
y_lower = 10
for i in range(n_clusters):
    ith_cluster_silhouette_values = silhouette_values[cluster_labels == i]
    ith_cluster_silhouette_values.sort()

    size_cluster_i = ith_cluster_silhouette_values.shape[0]
    y_upper = y_lower + size_cluster_i

    ax.fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_silhouette_values)
    ax.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))

    y_lower = y_upper + 10  # 10 for the 0 samples separation

ax.set_title(f"Silhouette plot for {n_clusters} clusters")
ax.set_xlabel("Silhouette coefficient values")
ax.set_ylabel("Cluster label")

ax.axvline(x=silhouette_avg, color="red", linestyle="--")
plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)

# Ploting Davies-Bouldin Score

from sklearn.metrics import davies_bouldin_score

# Try a range of cluster numbers
cluster_range = range(2, 10)
davies_bouldin_scores = []

for n_clusters in cluster_range:
    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
    cluster_labels = kmeans.fit_predict(data_scaled)

    # Calculate Davies-Bouldin score
    score = davies_bouldin_score(data_scaled, cluster_labels)
    davies_bouldin_scores.append(score)

# Plot the Davies-Bouldin Score vs. Number of Clusters
plt.figure(figsize=(8, 6))
plt.plot(cluster_range, davies_bouldin_scores, marker='o')
plt.title("Davies-Bouldin Score vs. Number of Clusters")
plt.xlabel("Number of Clusters")
plt.ylabel("Davies-Bouldin Score")
plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)
/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)

#Using PCA to Improve Clustering

# Fit PCA
pca = PCA(n_components=2)
principal_components = pca.fit_transform(data_scaled)

# Reconstruct the original data
data_reconstructed = pca.inverse_transform(principal_components)

# Calculate the reconstruction error
reconstruction_error = np.mean((data_scaled - data_reconstructed)**2, axis=1)

# Plot or analyze the reconstruction error to detect anomalies
print(reconstruction_error)

[0.56780141 0.52508574 0.55537322 ... 0.37338304 0.34342813 0.30709377]

numeric_features = ['Air temperature [K]', 'Process temperature [K]', 'Rotational speed [rpm]', 'Torque [Nm]', 'Tool wear [min]']

# Standardize the data
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data[numeric_features])

# Apply PCA to reduce dimensionality
pca = PCA(n_components=2)  # Reduce to 2 dimensions
data_pca = pca.fit_transform(data_scaled)

# Perform KMeans clustering on the reduced data
kmeans = KMeans(n_clusters=3, random_state=42)  # Adjust number of clusters if needed
cluster_labels = kmeans.fit_predict(data_pca)

# Calculate Silhouette and Davies-Bouldin Scores
silhouette_avg = silhouette_score(data_pca, cluster_labels)
db_score = davies_bouldin_score(data_pca, cluster_labels)

print(f'Silhouette Score after PCA: {silhouette_avg}')
print(f'Davies-Bouldin Score after PCA: {db_score}')

# Plot the clusters
plt.scatter(data_pca[:, 0], data_pca[:, 1], c=cluster_labels, cmap='viridis')
plt.title('PCA-based Clustering')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.colorbar(label='Cluster Label')
plt.show()

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning
  super()._check_params_vs_input(X, default_n_init=10)

Silhouette Score after PCA: 0.3817583868877164
Davies-Bouldin Score after PCA: 0.88204400286295

# DBSCAN Clustering

# Standardize the data
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data[numeric_features])

# Apply DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)  # Adjust eps and min_samples based on your data
cluster_labels = dbscan.fit_predict(data_scaled)

# Calculate Silhouette and Davies-Bouldin Scores
if len(set(cluster_labels)) > 1:  # Ensure there's more than one cluster
    silhouette_avg = silhouette_score(data_scaled, cluster_labels)
    db_score = davies_bouldin_score(data_scaled, cluster_labels)
else:
    silhouette_avg, db_score = "Not applicable (1 or 0 clusters)", "Not applicable (1 or 0 clusters)"

print(f'Silhouette Score with DBSCAN: {silhouette_avg}')
print(f'Davies-Bouldin Score with DBSCAN: {db_score}')

# Plot the clusters
plt.scatter(data_scaled[:, 0], data_scaled[:, 1], c=cluster_labels, cmap='viridis')
plt.title('DBSCAN Clustering')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Cluster Label')
plt.show()

Silhouette Score with DBSCAN: -0.020237654646290137
Davies-Bouldin Score with DBSCAN: 1.9245309197572258

# GMM Clustering - Gaussian Mixture

# Standardize the data
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data[numeric_features])

# Apply Gaussian Mixture Model (GMM)
gmm = GaussianMixture(n_components=3, random_state=42)  # Adjust number of clusters if needed
gmm_labels = gmm.fit_predict(data_scaled)

# Calculate Silhouette and Davies-Bouldin Scores
silhouette_avg = silhouette_score(data_scaled, gmm_labels)
db_score = davies_bouldin_score(data_scaled, gmm_labels)

print(f'Silhouette Score with GMM: {silhouette_avg}')
print(f'Davies-Bouldin Score with GMM: {db_score}')

# Plot the clusters
plt.scatter(data_scaled[:, 0], data_scaled[:, 1], c=gmm_labels, cmap='viridis')
plt.title('GMM Clustering')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Cluster Label')
plt.show()

Silhouette Score with GMM: 0.2536048282645372
Davies-Bouldin Score with GMM: 1.2984866092354108

	UDI	Air temperature [K]	Process temperature [K]	Rotational speed [rpm]	Torque [Nm]	Tool wear [min]	Machine failure	TWF	HDF	PWF	OSF	RNF
count	10000.00000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.000000	10000.00000
mean	5000.50000	300.004930	310.005560	1538.776100	39.986910	107.951000	0.033900	0.004600	0.011500	0.009500	0.009800	0.00190
std	2886.89568	2.000259	1.483734	179.284096	9.968934	63.654147	0.180981	0.067671	0.106625	0.097009	0.098514	0.04355
min	1.00000	295.300000	305.700000	1168.000000	3.800000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.00000
25%	2500.75000	298.300000	308.800000	1423.000000	33.200000	53.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.00000
50%	5000.50000	300.100000	310.100000	1503.000000	40.100000	108.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.00000
75%	7500.25000	301.500000	311.100000	1612.000000	46.800000	162.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.00000
max	10000.00000	304.500000	313.800000	2886.000000	76.600000	253.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.00000

	UDI	Product ID	Type	Air temperature [K]	Process temperature [K]	Rotational speed [rpm]	Torque [Nm]	Tool wear [min]
0	1	M14860	M	298.1	308.6	1551	42.8	0
1	2	L47181	L	298.2	308.7	1408	46.3	3
2	3	L47182	L	298.1	308.5	1498	49.4	5
3	4	L47183	L	298.2	308.6	1433	39.5	7
4	5	L47184	L	298.2	308.7	1408	40.0	9

	UDI	Product ID	Type	Air temperature [K]	Process temperature [K]	Rotational speed [rpm]	Torque [Nm]	Tool wear [min]
0	1	M14860	2	298.1	308.6	1551	42.8	0
1	2	L47181	1	298.2	308.7	1408	46.3	3
2	3	L47182	1	298.1	308.5	1498	49.4	5
3	4	L47183	1	298.2	308.6	1433	39.5	7
4	5	L47184	1	298.2	308.7	1408	40.0	9

	0
UDI	10000
Product ID	10000
Type	3
Air temperature [K]	93
Process temperature [K]	82
Rotational speed [rpm]	941
Torque [Nm]	577
Tool wear [min]	246
Machine failure	2
TWF	2
HDF	2
PWF	2
OSF	2
RNF	2

	UDI	Product ID	Type	Air temperature [K]	Process temperature [K]	Rotational speed [rpm]	Torque [Nm]	Tool wear [min]	Machine failure
0	1	M14860	2	-0.952389	-0.947360	0.068185	0.282200	-1.695984	0
1	2	L47181	1	-0.902393	-0.879959	-0.729472	0.633308	-1.648852	0
2	3	L47182	1	-0.952389	-1.014761	-0.227450	0.944290	-1.617430	0
3	4	L47183	1	-0.902393	-0.947360	-0.590021	-0.048845	-1.586009	0
4	5	L47184	1	-0.902393	-0.879959	-0.729472	0.001313	-1.554588	0
...	...	...	...	...	...	...	...	...	...
9995	9996	M24855	2	-0.602417	-1.082162	0.363820	-1.052012	-1.476034	0
9996	9997	H39410	0	-0.552421	-1.082162	0.520005	-0.821283	-1.428902	0
9997	9998	M24857	2	-0.502425	-0.947360	0.592519	-0.660777	-1.350349	0
9998	9999	H39412	0	-0.502425	-0.879959	-0.729472	0.854005	-1.303217	0
9999	10000	M24859	2	-0.502425	-0.879959	-0.216294	0.021376	-1.224663	0

Predictive Maintenance for Industrial Equipment¶

INTRODUCTION¶

PROJECT OVERVIEW¶

Dataset Description¶

Techniques and Methodologies¶

LIBRARIES¶

Import the Predictive Maintenance Dataset¶

DATA PREPROCESSING¶

Column Description¶

EXPLORATORY DATA ANALYSIS (EDA)¶

Count of Product Types Bar Chart Analysis¶

Distribution of Process Temperature Histogram Analysis¶

Rotational Speed vs. Torque Scatter Plot Analysis¶

Distribution of Torque Histogram Analysis¶

Torque by Product Type Box Plot Analysis¶

Tool Wear by Machine Failure Box Plot Analysis¶

Violin Plot of Tool Wear by Product Type Analysis¶

Distribution of Machine Failures Histogram Analysis¶

Heatmap of Product Type vs. Machine Failure¶

Torque by Product Type and Machine Failure Analysis¶

Rotational Speed and Tool Wear Over Time Analysis¶

FEATURE ENGINEERING¶

Handling Null Values¶

Encoding Categorical Variables¶

Handling Class Imbalance:¶

Why is this imbalance important?¶

Handling the Class Imbalance: Code Explanation¶

Importance of Handling Class Imbalance¶

Scaling and Normalization¶

Feature Creation¶

Analysis¶

Analysis¶

ROC Curve Analysis¶

Feature Importance Chart Analyis¶

Dimensional Reduction¶

PCA Interpretation¶

Analysis¶

Model Accuracy Analysis¶

Model Loss Analysis¶

Anomaly Detection Analysis¶

Code Explanation¶

Silhouette Score Analysis¶

Davies-Bouldin Score Analysis¶

Analyzing the Silhouette and Davies-Bouldin Score metrics¶

Using PCA to Improve Clustering¶

PCA-based Clustering¶

Dimensionality Reduction¶

Evaluation with Silhouette and Davies-Bouldin Scores¶

Interpretation of Cluster Groups¶

Further Analysis¶

Wrapping up¶

CONCLUSION¶

Key outcomes of the project include¶

Learning Techniques used in this project¶

REFERENCES¶